"""
__L2_FF2FF_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Wed Dec 12 18:25:29 2012
______________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Female_S import *
from MatchModel import *
from ApplyModel import *
from Female_T import *
from match_contains import *
from apply_contains import *
from backward_link import *
from indirectLink_S import *
from directLink_T import *
from graph_backward_link import *
from graph_ApplyModel import *
from graph_directLink_T import *
from graph_MatchModel import *
from graph_apply_contains import *
from graph_match_contains import *
from graph_Female_S import *
from graph_Female_T import *
from graph_indirectLink_S import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def L2_FF2FF_MDL(self, rootNode, SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG SimpleDSLTransMM ---
    if( SimpleDSLTransMMRootNode ): 
        # author
        SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        SimpleDSLTransMMRootNode.description.setValue('\n')
        SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        SimpleDSLTransMMRootNode.name.setValue('FF2FF')
    # --- ASG attributes over ---


    self.obj86=Female_S(self)
    self.obj86.isGraphObjectVisual = True

    if(hasattr(self.obj86, '_setHierarchicalLink')):
      self.obj86._setHierarchicalLink(False)

    # name
    self.obj86.name.setValue('f1')

    self.obj86.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(620.0,260.0,self.obj86)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj86.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj86)
    self.globalAndLocalPostcondition(self.obj86, rootNode)
    self.obj86.postAction( rootNode.CREATE )

    self.obj88=Female_S(self)
    self.obj88.isGraphObjectVisual = True

    if(hasattr(self.obj88, '_setHierarchicalLink')):
      self.obj88._setHierarchicalLink(False)

    # name
    self.obj88.name.setValue('f2')

    self.obj88.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(860.0,260.0,self.obj88)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj88.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj88)
    self.globalAndLocalPostcondition(self.obj88, rootNode)
    self.obj88.postAction( rootNode.CREATE )

    self.obj74=MatchModel(self)
    self.obj74.isGraphObjectVisual = True

    if(hasattr(self.obj74, '_setHierarchicalLink')):
      self.obj74._setHierarchicalLink(False)

    self.obj74.graphClass_= graph_MatchModel
    if self.genGraphics:
       new_obj = graph_MatchModel(360.0,200.0,self.obj74)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj74.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj74)
    self.globalAndLocalPostcondition(self.obj74, rootNode)
    self.obj74.postAction( rootNode.CREATE )

    self.obj75=ApplyModel(self)
    self.obj75.isGraphObjectVisual = True

    if(hasattr(self.obj75, '_setHierarchicalLink')):
      self.obj75._setHierarchicalLink(False)

    self.obj75.graphClass_= graph_ApplyModel
    if self.genGraphics:
       new_obj = graph_ApplyModel(360.0,440.0,self.obj75)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj75.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj75)
    self.globalAndLocalPostcondition(self.obj75, rootNode)
    self.obj75.postAction( rootNode.CREATE )

    self.obj89=Female_T(self)
    self.obj89.isGraphObjectVisual = True

    if(hasattr(self.obj89, '_setHierarchicalLink')):
      self.obj89._setHierarchicalLink(False)

    # name
    self.obj89.name.setValue('f1')

    self.obj89.graphClass_= graph_Female_T
    if self.genGraphics:
       new_obj = graph_Female_T(620.0,500.0,self.obj89)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj89.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj89)
    self.globalAndLocalPostcondition(self.obj89, rootNode)
    self.obj89.postAction( rootNode.CREATE )

    self.obj90=Female_T(self)
    self.obj90.isGraphObjectVisual = True

    if(hasattr(self.obj90, '_setHierarchicalLink')):
      self.obj90._setHierarchicalLink(False)

    # name
    self.obj90.name.setValue('f2')

    self.obj90.graphClass_= graph_Female_T
    if self.genGraphics:
       new_obj = graph_Female_T(860.0,500.0,self.obj90)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj90.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj90)
    self.globalAndLocalPostcondition(self.obj90, rootNode)
    self.obj90.postAction( rootNode.CREATE )

    self.obj91=match_contains(self)
    self.obj91.isGraphObjectVisual = True

    if(hasattr(self.obj91, '_setHierarchicalLink')):
      self.obj91._setHierarchicalLink(False)

    self.obj91.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(551.0,271.0,self.obj91)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj91.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj91)
    self.globalAndLocalPostcondition(self.obj91, rootNode)
    self.obj91.postAction( rootNode.CREATE )

    self.obj93=match_contains(self)
    self.obj93.isGraphObjectVisual = True

    if(hasattr(self.obj93, '_setHierarchicalLink')):
      self.obj93._setHierarchicalLink(False)

    self.obj93.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(671.0,271.0,self.obj93)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj93.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj93)
    self.globalAndLocalPostcondition(self.obj93, rootNode)
    self.obj93.postAction( rootNode.CREATE )

    self.obj92=apply_contains(self)
    self.obj92.isGraphObjectVisual = True

    if(hasattr(self.obj92, '_setHierarchicalLink')):
      self.obj92._setHierarchicalLink(False)

    self.obj92.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(553.5,511.0,self.obj92)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj92.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj92)
    self.globalAndLocalPostcondition(self.obj92, rootNode)
    self.obj92.postAction( rootNode.CREATE )

    self.obj94=apply_contains(self)
    self.obj94.isGraphObjectVisual = True

    if(hasattr(self.obj94, '_setHierarchicalLink')):
      self.obj94._setHierarchicalLink(False)

    self.obj94.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(673.5,511.0,self.obj94)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj94.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj94)
    self.globalAndLocalPostcondition(self.obj94, rootNode)
    self.obj94.postAction( rootNode.CREATE )

    self.obj105=backward_link(self)
    self.obj105.isGraphObjectVisual = True

    if(hasattr(self.obj105, '_setHierarchicalLink')):
      self.obj105._setHierarchicalLink(False)

    self.obj105.graphClass_= graph_backward_link
    if self.genGraphics:
       new_obj = graph_backward_link(681.0,421.0,self.obj105)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj105.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj105)
    self.globalAndLocalPostcondition(self.obj105, rootNode)
    self.obj105.postAction( rootNode.CREATE )

    self.obj106=backward_link(self)
    self.obj106.isGraphObjectVisual = True

    if(hasattr(self.obj106, '_setHierarchicalLink')):
      self.obj106._setHierarchicalLink(False)

    self.obj106.graphClass_= graph_backward_link
    if self.genGraphics:
       new_obj = graph_backward_link(921.0,421.0,self.obj106)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj106.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj106)
    self.globalAndLocalPostcondition(self.obj106, rootNode)
    self.obj106.postAction( rootNode.CREATE )

    self.obj103=indirectLink_S(self)
    self.obj103.isGraphObjectVisual = True

    if(hasattr(self.obj103, '_setHierarchicalLink')):
      self.obj103._setHierarchicalLink(False)

    self.obj103.graphClass_= graph_indirectLink_S
    if self.genGraphics:
       new_obj = graph_indirectLink_S(801.0,301.0,self.obj103)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("indirectLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj103.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj103)
    self.globalAndLocalPostcondition(self.obj103, rootNode)
    self.obj103.postAction( rootNode.CREATE )

    self.obj104=directLink_T(self)
    self.obj104.isGraphObjectVisual = True

    if(hasattr(self.obj104, '_setHierarchicalLink')):
      self.obj104._setHierarchicalLink(False)

    self.obj104.graphClass_= graph_directLink_T
    if self.genGraphics:
       new_obj = graph_directLink_T(801.0,541.0,self.obj104)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj104.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj104)
    self.globalAndLocalPostcondition(self.obj104, rootNode)
    self.obj104.postAction( rootNode.CREATE )

    # Connections for obj86 (graphObject_: Obj49) named f1
    self.drawConnections(
(self.obj86,self.obj103,[681.0, 301.0, 801.0, 301.0],"true", 2) )
    # Connections for obj88 (graphObject_: Obj51) named f2
    self.drawConnections(
 )
    # Connections for obj74 (graphObject_: Obj37) of type MatchModel
    self.drawConnections(
(self.obj74,self.obj91,[421.0, 241.0, 551.0, 271.0],"true", 2),
(self.obj74,self.obj93,[421.0, 241.0, 671.0, 271.0],"true", 2) )
    # Connections for obj75 (graphObject_: Obj38) of type ApplyModel
    self.drawConnections(
(self.obj75,self.obj92,[426.0, 481.0, 553.5, 511.0],"true", 2),
(self.obj75,self.obj94,[426.0, 481.0, 673.5, 511.0],"true", 2) )
    # Connections for obj89 (graphObject_: Obj52) named f1
    self.drawConnections(
(self.obj89,self.obj104,[681.0, 541.0, 801.0, 541.0],"true", 2),
(self.obj89,self.obj105,[681.0, 541.0, 681.0, 421.0],"true", 2) )
    # Connections for obj90 (graphObject_: Obj53) named f2
    self.drawConnections(
(self.obj90,self.obj106,[921.0, 541.0, 921.0, 421.0],"true", 2) )
    # Connections for obj91 (graphObject_: Obj54) of type match_contains
    self.drawConnections(
(self.obj91,self.obj86,[551.0, 271.0, 681.0, 301.0],"true", 2) )
    # Connections for obj93 (graphObject_: Obj56) of type match_contains
    self.drawConnections(
(self.obj93,self.obj88,[671.0, 271.0, 921.0, 301.0],"true", 2) )
    # Connections for obj92 (graphObject_: Obj55) of type apply_contains
    self.drawConnections(
(self.obj92,self.obj89,[553.5, 511.0, 681.0, 541.0],"true", 2) )
    # Connections for obj94 (graphObject_: Obj57) of type apply_contains
    self.drawConnections(
(self.obj94,self.obj90,[673.5, 511.0, 921.0, 541.0],"true", 2) )
    # Connections for obj105 (graphObject_: Obj60) of type backward_link
    self.drawConnections(
(self.obj105,self.obj86,[681.0, 421.0, 681.0, 301.0],"true", 2) )
    # Connections for obj106 (graphObject_: Obj61) of type backward_link
    self.drawConnections(
(self.obj106,self.obj88,[921.0, 421.0, 921.0, 301.0],"true", 2) )
    # Connections for obj103 (graphObject_: Obj58) of type indirectLink_S
    self.drawConnections(
(self.obj103,self.obj88,[801.0, 301.0, 921.0, 301.0],"true", 2) )
    # Connections for obj104 (graphObject_: Obj59) of type directLink_T
    self.drawConnections(
(self.obj104,self.obj90,[801.0, 541.0, 921.0, 541.0],"true", 2) )

newfunction = L2_FF2FF_MDL

loadedMMName = 'SimpleDSLTransMM_META'

atom3version = '0.3'
